YES 1.928 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could successfully be proven:



↳ HASKELL
  ↳ LR

mainModule List
  ((group :: [Bool]  ->  [[Bool]]) :: [Bool]  ->  [[Bool]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy _ [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = (\(ys,_) ->ys) vv10
zs = (\(_,zs) ->zs) vv10


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(_,zs)→zs

is transformed to
zs0 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys0 (ys,_) = ys

The following Lambda expression
\(_,zs)→zs

is transformed to
zs1 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys1 (ys,_) = ys



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR

mainModule List
  ((group :: [Bool]  ->  [[Bool]]) :: [Bool]  ->  [[Bool]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy _ [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,_) = ys
zs = zs0 vv10
zs0 (_,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
xs@(wu : wv)

is replaced by the following term
wu : wv



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR

mainModule List
  ((group :: [Bool]  ->  [[Bool]]) :: [Bool]  ->  [[Bool]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,vx) = ys
zs = zs0 vv10
zs0 (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
span p [] = ([],[])
span p (wu : wv)
 | p wu
 = (wu : ys,zs)
 | otherwise
 = ([],wu : wv)
where 
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

is transformed to
span p [] = span3 p []
span p (wu : wv) = span2 p (wu : wv)

span2 p (wu : wv) = 
span1 p wu wv (p wu)
where 
span0 p wu wv True = ([],wu : wv)
span1 p wu wv True = (wu : ys,zs)
span1 p wu wv False = span0 p wu wv otherwise
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

span3 p [] = ([],[])
span3 xv xw = span2 xv xw



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed

mainModule List
  ((group :: [Bool]  ->  [[Bool]]) :: [Bool]  ->  [[Bool]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,vx) = ys
zs = zs0 vv10
zs0 (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
(x : ys) : groupBy eq zs
where 
vv10  = span (eq x) xs
ys  = ys0 vv10
ys0 (ys,vx) = ys
zs  = zs0 vv10
zs0 (vy,zs) = zs

are unpacked to the following functions on top level
groupByVv10 xx xy xz = span (xx xy) xz

groupByZs0 xx xy xz (vy,zs) = zs

groupByYs xx xy xz = groupByYs0 xx xy xz (groupByVv10 xx xy xz)

groupByYs0 xx xy xz (ys,vx) = ys

groupByZs xx xy xz = groupByZs0 xx xy xz (groupByVv10 xx xy xz)

The bindings of the following Let/Where expression
span1 p wu wv (p wu)
where 
span0 p wu wv True = ([],wu : wv)
span1 p wu wv True = (wu : ys,zs)
span1 p wu wv False = span0 p wu wv otherwise
vu43  = span p wv
ys  = ys1 vu43
ys1 (ys,wx) = ys
zs  = zs1 vu43
zs1 (ww,zs) = zs

are unpacked to the following functions on top level
span2Ys1 yu yv (ys,wx) = ys

span2Ys yu yv = span2Ys1 yu yv (span2Vu43 yu yv)

span2Vu43 yu yv = span yu yv

span2Span0 yu yv p wu wv True = ([],wu : wv)

span2Span1 yu yv p wu wv True = (wu : span2Ys yu yv,span2Zs yu yv)
span2Span1 yu yv p wu wv False = span2Span0 yu yv p wu wv otherwise

span2Zs yu yv = span2Zs1 yu yv (span2Vu43 yu yv)

span2Zs1 yu yv (ww,zs) = zs



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow

mainModule List
  (group :: [Bool]  ->  [[Bool]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = (x : groupByYs eq x xs) : groupBy eq (groupByZs eq x xs)

  
groupByVv10 xx xy xz = span (xx xy) xz

  
groupByYs xx xy xz = groupByYs0 xx xy xz (groupByVv10 xx xy xz)

  
groupByYs0 xx xy xz (ys,vx) = ys

  
groupByZs xx xy xz = groupByZs0 xx xy xz (groupByVv10 xx xy xz)

  
groupByZs0 xx xy xz (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs(:(True, yw3111)) → new_span2Ys(yw3111)
new_span2Ys(:(True, yw3111)) → new_span2Zs(yw3111)
new_span2Zs(:(True, yw3111)) → new_span2Zs(yw3111)
new_span2Ys(:(True, yw3111)) → new_span2Ys(yw3111)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys0(:(False, yw3111)) → new_span2Zs0(yw3111)
new_span2Zs0(:(False, yw3111)) → new_span2Ys0(yw3111)
new_span2Ys0(:(False, yw3111)) → new_span2Ys0(yw3111)
new_span2Zs0(:(False, yw3111)) → new_span2Zs0(yw3111)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

new_groupBy(:(yw30, yw31)) → new_groupBy(new_groupByZs0(yw30, yw31))

The TRS R consists of the following rules:

new_span2Ys2([]) → []
new_groupByZs0(True, :(True, yw311)) → new_span2Zs1(yw311)
new_span2Zs1([]) → []
new_span2Zs11(yw3111, yw11, yw10) → yw10
new_span2Ys2(:(True, yw3111)) → new_span2Ys10(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_span2Zs1(:(False, yw3111)) → :(False, yw3111)
new_span2Ys3([]) → []
new_span2Zs2([]) → []
new_groupByZs0(True, :(False, yw311)) → :(False, yw311)
new_span2Ys10(yw3111, yw7, yw6) → :(True, yw7)
new_groupByZs0(yw30, []) → []
new_span2Zs1(:(True, yw3111)) → new_span2Zs11(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_span2Ys2(:(False, yw3111)) → []
new_groupByZs0(False, :(True, yw311)) → :(True, yw311)
new_groupByZs0(False, :(False, yw311)) → new_span2Zs2(yw311)
new_span2Ys3(:(False, yw3111)) → new_span2Ys1(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Zs2(:(False, yw3111)) → new_span2Zs10(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Zs10(yw3111, yw9, yw8) → yw8
new_span2Ys1(yw3111, yw5, yw4) → :(False, yw5)
new_span2Zs2(:(True, yw3111)) → :(True, yw3111)
new_span2Ys3(:(True, yw3111)) → []

The set Q consists of the following terms:

new_groupByZs0(False, :(True, x0))
new_span2Ys2([])
new_span2Zs1([])
new_span2Ys3(:(True, x0))
new_span2Ys2(:(True, x0))
new_groupByZs0(False, :(False, x0))
new_span2Zs11(x0, x1, x2)
new_span2Zs2(:(True, x0))
new_span2Zs1(:(False, x0))
new_span2Ys10(x0, x1, x2)
new_span2Zs10(x0, x1, x2)
new_groupByZs0(x0, [])
new_span2Zs1(:(True, x0))
new_span2Zs2([])
new_span2Ys3([])
new_groupByZs0(True, :(False, x0))
new_groupByZs0(True, :(True, x0))
new_span2Zs2(:(False, x0))
new_span2Ys3(:(False, x0))
new_span2Ys2(:(False, x0))
new_span2Ys1(x0, x1, x2)

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [15].


The following pairs can be oriented strictly and are deleted.


new_groupBy(:(yw30, yw31)) → new_groupBy(new_groupByZs0(yw30, yw31))
The remaining pairs can at least be oriented weakly.
none
Used ordering: Polynomial interpretation [25]:

POL(:(x1, x2)) = 1 + x2   
POL(False) = 0   
POL(True) = 0   
POL([]) = 0   
POL(new_groupBy(x1)) = x1   
POL(new_groupByZs0(x1, x2)) = x2   
POL(new_span2Ys1(x1, x2, x3)) = 1 + x2   
POL(new_span2Ys10(x1, x2, x3)) = 1 + x2   
POL(new_span2Ys2(x1)) = 1 + x1   
POL(new_span2Ys3(x1)) = x1   
POL(new_span2Zs1(x1)) = x1   
POL(new_span2Zs10(x1, x2, x3)) = 1 + x3   
POL(new_span2Zs11(x1, x2, x3)) = x3   
POL(new_span2Zs2(x1)) = x1   

The following usable rules [17] were oriented:

new_span2Zs1(:(False, yw3111)) → :(False, yw3111)
new_groupByZs0(True, :(True, yw311)) → new_span2Zs1(yw311)
new_span2Ys1(yw3111, yw5, yw4) → :(False, yw5)
new_span2Ys3(:(False, yw3111)) → new_span2Ys1(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Zs2(:(True, yw3111)) → :(True, yw3111)
new_span2Ys3([]) → []
new_span2Zs1([]) → []
new_groupByZs0(False, :(False, yw311)) → new_span2Zs2(yw311)
new_span2Zs1(:(True, yw3111)) → new_span2Zs11(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_span2Zs11(yw3111, yw11, yw10) → yw10
new_span2Zs2([]) → []
new_groupByZs0(False, :(True, yw311)) → :(True, yw311)
new_span2Ys3(:(True, yw3111)) → []
new_groupByZs0(yw30, []) → []
new_span2Ys2([]) → []
new_span2Ys2(:(True, yw3111)) → new_span2Ys10(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_groupByZs0(True, :(False, yw311)) → :(False, yw311)
new_span2Ys2(:(False, yw3111)) → []
new_span2Zs10(yw3111, yw9, yw8) → yw8
new_span2Zs2(:(False, yw3111)) → new_span2Zs10(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Ys10(yw3111, yw7, yw6) → :(True, yw7)



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPOrderProof
                          ↳ QDP
                            ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

new_span2Ys2([]) → []
new_groupByZs0(True, :(True, yw311)) → new_span2Zs1(yw311)
new_span2Zs1([]) → []
new_span2Zs11(yw3111, yw11, yw10) → yw10
new_span2Ys2(:(True, yw3111)) → new_span2Ys10(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_span2Zs1(:(False, yw3111)) → :(False, yw3111)
new_span2Ys3([]) → []
new_span2Zs2([]) → []
new_groupByZs0(True, :(False, yw311)) → :(False, yw311)
new_span2Ys10(yw3111, yw7, yw6) → :(True, yw7)
new_groupByZs0(yw30, []) → []
new_span2Zs1(:(True, yw3111)) → new_span2Zs11(yw3111, new_span2Ys2(yw3111), new_span2Zs1(yw3111))
new_span2Ys2(:(False, yw3111)) → []
new_groupByZs0(False, :(True, yw311)) → :(True, yw311)
new_groupByZs0(False, :(False, yw311)) → new_span2Zs2(yw311)
new_span2Ys3(:(False, yw3111)) → new_span2Ys1(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Zs2(:(False, yw3111)) → new_span2Zs10(yw3111, new_span2Ys3(yw3111), new_span2Zs2(yw3111))
new_span2Zs10(yw3111, yw9, yw8) → yw8
new_span2Ys1(yw3111, yw5, yw4) → :(False, yw5)
new_span2Zs2(:(True, yw3111)) → :(True, yw3111)
new_span2Ys3(:(True, yw3111)) → []

The set Q consists of the following terms:

new_groupByZs0(False, :(True, x0))
new_span2Ys2([])
new_span2Zs1([])
new_span2Ys3(:(True, x0))
new_span2Ys2(:(True, x0))
new_groupByZs0(False, :(False, x0))
new_span2Zs11(x0, x1, x2)
new_span2Zs2(:(True, x0))
new_span2Zs1(:(False, x0))
new_span2Ys10(x0, x1, x2)
new_span2Zs10(x0, x1, x2)
new_groupByZs0(x0, [])
new_span2Zs1(:(True, x0))
new_span2Zs2([])
new_span2Ys3([])
new_groupByZs0(True, :(False, x0))
new_groupByZs0(True, :(True, x0))
new_span2Zs2(:(False, x0))
new_span2Ys3(:(False, x0))
new_span2Ys2(:(False, x0))
new_span2Ys1(x0, x1, x2)

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.